A Dynamic Random Access Memory (DRAM) has memory arrays consisting of a number of memory cells arranged in rows and columns. In a conventional DRAM each memory cell (sometimes referred to as a memory bit or element) consists of one transistor and one capacitor. A terminal of the transistor is connected to a digit line (sometimes referred to as a bit line) of the memory device. Another terminal of the transistor is connected to a terminal of the capacitor, and the gate terminal of the transistor is connected to an access line (sometimes referred to as a word line) of the memory device. The transistor acts as a gate between the digit line and the capacitor. A second terminal of the capacitor is connected to a voltage rail that carries a voltage, such as VCC/2. When the word line for a particular cell is activated, the gate transistor is in a conducting state and the capacitor is connected to the digit line. The capacitor stores a charge that, depending on whether the polarity of the voltage across the capacitor is positive or negative, represents either a logic high value or a logic low value. For ease of discussion, and not limitation to any specific configuration, access lines and digit lines may also be referred to herein as rows and columns, respectively.
Conventionally, particular access and column select lines are activated to access selected memory cells. “Access” conventionally refers to reading data from, or writing data to, selected memory cells. Reading data from the memory cells conventionally involves the use of detecting circuitry (e.g., sensing circuitry including a sense amplifier), to determine whether the charge stored in a memory cell represents a binary one or a binary zero.
During test and operation, memory cells in the array may be discovered to be defective. Memory cells that are found to be defective may be replaced with a replacement (e.g., redundant) memory cell. Conventionally, the entire row or column with the defective memory cell is replaced with a replacement (e.g., redundant) row or column, respectively. For example, to replace a row with a defective memory cell, control logic, such as a row address decoder, may be programmed to map a replacement row to the address of the row which includes the defective memory cell, and to disable data access to the row which includes the defective memory cell. Therefore, when an external circuit attempts to read data from or attempts to write data to the defective row, the row address decoder may not activate the defective row but, instead, activates the replacement row so that data may be transferred to or from a corresponding addressed memory cell or cells within the replacement row. Replacement rows are conventionally distributed throughout the array. During refresh operations, replacement rows may be fired and refreshed at times when such an operation may cause data corruption or other failure. Such times may arise when adjacent rows, or any pair of rows sharing a sense amplifier, are refreshed during the same refresh operation.
FIG. 1 illustrates a simplified architecture of a memory array 100. Memory array 100 includes a core array 110 divided up into sections 0-31. Core array 110 sections include memory cells arranged in logical (and, in many cases, physical) rows. Data may be accessed by addressing the memory cells through control logic, such as a row decoder (not shown) and/or a column decoder 130 (Coldec). Between each section of the core array 110 is detecting circuitry (e.g., sensing circuitry), which may include sense amplifiers 115 (sa0-sa30). Distributed replacement elements 111 may be distributed throughout the sections of the core array 110. Distributed replacement elements 111 may be used to replace defective rows in the core array.
Row control logic (not shown) uses address inputs to determine which rows to activate in which sections. For example, row decoders (see FIG. 3) may be coupled to each core array 110 section to activate the currently addressed rows and the associated sense amplifiers 115. In addition, the row control logic is used to determine which replacement rows to activate in the distributed replacement elements 111 when the distributed replacement elements 111 are used to replace elements in the core array 110 sections. Meanwhile, the column decoder 130 may activate the appropriate digit lines from sense amplifiers 115 to pass the memory cells to the appropriate IO bus (not shown).
As an example, memory array 100 may be configured as a 64M array with approximately 16 k word lines. To create a 64M array with 16 k word lines, there may be as many as 4 k digit lines depending on the number of bits per digit line (i.e., width). In this 64M array example, 16 k word lines are addressed in order to access the information stored on the memory array 100. WL0 may be the first word line in section 0, and WL16k may be the last word line in section 31. In memory array 100, each section includes 512 word lines.
FIG. 2 is a simplified circuit diagram of a sense amplifier 115, which may be used as a folded digit line sense amplifier or an open digit line sense amplifier. Memory devices are conventionally constructed with complementary digit lines of equal capacitance. Sense amplifiers are connected between the complementary digit lines and can operate to sense the differential voltage, differential current, or a combination thereof across the complementary digit lines. A sense amplifier 115, as illustrated in FIG. 2, features the sense amplifier circuits between arrays or sections of the memory array. True and complement digit lines D0 and D0* come from separate arrays or sections of the memory array on each side of the sense amplifiers. For the folded digit line sense amplifiers, the true and complement digit lines D0 and D0* come from the same side of the array or from the same section. As is generally known in the art, the term “sense amplifier” includes a collection of circuit elements connected to the complementary digit lines D0 and D0* of a DRAM array. This collection may include devices for equilibration and bias, one or more N-sense amplifiers, one or more P-sense amplifiers, and devices connecting activated digit lines to IO signal lines.
Operation of the sense amplifier 115 is accomplished by applying various signals to each sense amplifier to fire the sense amplifiers as is well known in the art. As shown in FIG. 2, sense amplifier 115 includes a P-sense amplifier 236 and an N-sense amplifier 234 for sensing charge stored in the activated memory cell of the activated array via a voltage differential on the pair of digit lines D0 and D0*.
An equilibration circuit 238 is provided to equilibrate the digit lines D0 and D0* and includes a transistor coupled between the digit line D0 and the complement digit line D0* and a gate coupled to receive an equilibration signal EQ. The equilibration circuit 238 also includes two transistors coupled in series between the digit line D0 and the complement digit line D0*. These two transistors also include gates coupled to the equilibration signal EQ. The two series transistors have drains coupled to an equilibration voltage Veq, which may be set to about Vcc/2. When the signal EQ is at a high logic level, the equilibration circuit 238 effectively shorts digit line D0 and complement digit line D0* such that they are both equilibrated to the voltage Veq.
The P-sense amplifier 236 and N-sense amplifier 234 operate to sense and amplify the differential signal between the pair of digit lines D0 and D0*. These amplifiers (234 and 236) work together to sense the accessed charge and drive the digit lines D0 and D0* to full voltage values of Vcc and ground. The N-sense amplifier 234 includes cross-coupled NMOS transistors and drives the low-potential digit line to ground. Similarly, the P-sense amplifier 236 includes cross-coupled PMOS transistors and drives the high-potential digit line to Vcc.
The common node of the cross-coupled NMOS transistors is labeled RNL*. Similarly, the common node of the cross-coupled PMOS transistors is labeled ACT (for ACTive pull-up). Initially, RNL* may be biased to Vcc/2 and ACT may be biased to ground. Since the digit line pair D0 and D0* are both initially at Vcc/2 volts, the N-sense-amplifier transistors remain off due to zero Vgs potential. Similarly, both P-sense-amplifier transistors remain off due to their positive Vgs potential. A signal voltage develops between the digit line pair D0 and D0* when the memory cell access occurs. While one digit line contains charge from the cell access, the other digit line serves as a reference for the sensing operation.
In many embodiments, the sense amplifier firing may occur sequentially rather than concurrently. The N-sense amplifier 234 may fire first and the P-sense amplifier 236 second. The N-sense amplifier 234 is fired by providing a signal, labeled NSA, to a transistor 235 connecting the common node of the N-sense amplifier 234 to ground. In other words, dropping the RNL* signal toward ground will fire the N-sense amplifier 234. As the voltage between RNL* and the digit lines approaches Vt, the NMOS transistor whose gate connection is to the higher-voltage digit line will begin to conduct. Conduction results in the discharge of the low-voltage digit line toward the RNL* voltage. Ultimately, RNL* will reach ground, bringing the digit line with it. Note that the other NMOS transistor will not conduct, since its gate voltage derives from the low-voltage digit line, which is discharging toward ground.
Shortly after the N-sense amplifier 234 fires, ACT will be driven toward Vcc by applying a low-signal PSA* to PMOS transistor 237, connecting the common node of the P-sense amplifier to Vcc. This activates the P-sense amplifier 236 that operates in a complementary fashion to the N-sense amplifier 234. With the low-voltage digit line approaching ground, a strong signal exists to drive the appropriate PMOS transistor into conduction. This will charge the high-voltage digit line toward Vcc, ultimately reaching Vcc. Since the memory cell transistor remains on during sensing, the memory cell capacitor will charge to the RNL* or ACT voltage level. The voltage, and hence charge, which the memory cell capacitor held prior to accessing will restore a full level, i.e., Vcc for a logic one and GND for a logic zero.
When P-sense amplifier 236 and N-sense amplifier 234 have sensed the differential voltage across the digit lines D0 and D0*, a signal representing the charge stored in the accessed memory cell is output from the sense amplifier 115 on the IO lines IO and IO*. An access block 239 includes two NMOS transistors that when enabled by a columns select signal CSEL, enable the transfer of voltage from the D0 signal to the IO signal and from D0* signal to the IO* signal.
To write to a memory bit, appropriate voltage levels of ground and VCC are placed on the IO and IO* signals and when CSEL is activated, those appropriate voltage levels will be driven onto the D0 and D0* signal respectively. The values on D0 and D0* are written into the appropriate memory cells that are activated corresponding to with a row address. Most of the discussion of operation herein focuses on reading the memory arrays. However, unless otherwise specified, memory accesses discussed herein should be considered to cover both reads and writes. Unless a write operation is specifically discussed, a person of ordinary skill in the art would be able to readily understand any differences between performing a read operation and a write operation. Furthermore, FIG. 2 is shown as one example of a sense amp to discuss general sense amp operation. Those of ordinary skill in the art will recognize that many sense amp designs and configurations can be used in embodiments of the present invention.
FIG. 3 illustrates a simplified architecture of a memory array 300 including a plurality of sub-arrays 301-304. In memory array 300, sub-arrays 301 and 302 are divided with a shared row decoder 305 to form a P side. Sub-arrays 303 and 304 are divided with a shared row decoder 306 to form a Q side. Each sub-array 301-304 may be configured similar to the individual memory array of FIG. 1. For example, each sub-array 301-304 may have its own column decoder 130. Each sub-array 301-304 may include distributed replacement elements 111 (not shown in FIG. 3; see FIG. 1) distributed throughout the sections of the core array 110. Distributed replacement elements 111 may be used as replacement elements for repairing defects associated with word lines of the sections of the sub-arrays 301-304. Distributed replacement elements 111 may also be used to replace word lines of the sections of the sub-arrays 301-304 for reasons other than repairing defects.
As an example, memory array 300 may be configured as a 256M array with approximately 32 k rows. With 32 k rows, memory array 300 may have as many as 8 k columns depending on the number of bits per column (i.e., width). For example, the P side of memory array 300 includes word lines 0-16 k, and the Q side of memory array 300 includes word lines 16 k-32 k. In other words, 32 k word lines are addressed in order to access the information stored on the memory array 300. To build a 256M array with four sub-arrays 301-304, each sub-array 301-304 may be a 64M memory array configured as described and shown in FIG. 1.
In operation, a word line is activated (also referred to as fired) horizontally from the row decoder 305 when oriented as shown in FIG. 3. Digit lines are activated vertically from the column decoders when oriented as shown in FIG. 3. For example, FIG. 3 shows word line 2056 being activated by firing across both sub-arrays 301, 302 on the P side of memory array 300.
FIG. 4 illustrates a simplified memory array 400 undergoing a refresh operation. Memory array 400 is configured as before with respect to FIG. 3 with sub-arrays 301-304 configured to share row decoders 305 and 306 to be divided into a P side and a Q side. As with FIG. 3, the present example shows a 256M memory array with four 64M sub-arrays. The P side is addressed from 0-16 k, and the Q side is addressed from 16 k-32 k. The core array 110 for each sub-array 301-304 is divided into 32 sections (sections 0-31), each section including 512 word lines. In other words, there are sections 0-31 for each of sub-arrays 301-304. Although FIG. 4 shows sections 0-31 on both of the P side and the Q side, other terminology may also be used. For example, the P side may include the sections 0-31 and the Q side may include sections 32-63.
A refresh operation may refer to an access of a word line. A refresh operation may include activating of multiple word lines concurrently or substantially concurrently with each other. The number of word lines activated during the same refresh operation may be related to the density of the memory array and the refresh rate. As discussed herein, when such a refresh operation is performed on neighboring word lines, data contention or noise may be introduced which may cause the memory array to not function properly.
The refresh operation illustrated in FIG. 4 is an 8 k refresh operation. This refresh rate refers to the number of word lines that are refreshed before starting over. Word lines are often refreshed sequentially as a row address counter increments the address of the word line to be refreshed. Conventionally, the refresh rate may be equal to the number of word lines in the memory array, such that one word line is refreshed at a time. For example, the first word line is refreshed and each subsequent word line is individually refreshed. When the last word line is refreshed, the refresh operation returns to the first word line.
The refresh rate may alternatively be different than the total number of word lines in a memory array needed to be refreshed. In that situation, in order for each word line to be refreshed, a plurality of word lines may need to be refreshed during the same refresh operation. For example, the 256M memory array illustrated in FIGS. 3 and 4 has sub-arrays 301-304 which form a P side and a Q side with shared row decoders for a total of 32 k word lines. Each of the 64M sub-arrays 301-304 have 16 k word lines. The refresh operation may increment in an upper half and a lower half of the memory array on both the P side and the Q side during the same refresh operation. In other words, in order to complete an 8 k refresh operation on a conventional 256M memory array with 32 k word lines, the refresh operation fires four times as many rows as would be required by the 256M memory array in a normal activation. A 64M array with 16 k word lines would fire two times as many rows at a time as would be required in a normal row activation. A normal row activation refers to a refresh rate equal to the number of word lines of the memory array (i.e., one word line is fired at a time).
In operation, in order to accomplish an 8 k refresh for 32 k word lines of the 256M array of FIG. 4, two rows may be fired on the P side, and two rows may be fired on the Q side during the same refresh operation. For example, in FIG. 4, word lines in sections 0 and 16 are fired in the same refresh operation on both the P side and the Q side of memory array 400. Sections 0 and 16 on the Q side may also be referred to as sections 32 and 48, respectively.
Because of the configuration of most conventional memory arrays, it may be easiest for sections that are 16 sections apart to fire at the same time (e.g., 0 and 16, 1 and 17, 15 and 31, and so on). This may be because two memory addresses may be configured to decode the memory array into sections. For example, the most significant bit of an address (e.g., address bit 14) may decide whether the row to be activated is on the P side or the Q side. The next most significant bit of an address (e.g., address bit 13) may decide whether the row to be activated is on the upper half (e.g., sections 16-31) or lower half (e.g., sections 0-15) of the memory array 400. Therefore, in order to fire four different rows during a refresh operation at substantially the same time, two of these addresses may become “don't care” sections (i.e., ignored bits), which allows an upper section and a lower section of both P and Q sides to fire at substantially the same time.
FIGS. 5A through 5C illustrate simplified memory arrays 500 undergoing a refresh operation, further showing the operation of detecting circuitry. As in previous examples, memory array 500 comprises a core array 110 divided into array sections. In these examples, memory array 500 may be configured as a 64M memory array with thirty-two core array sections (sections 0-31), such as might be used alone or as a sub-array on the P or Q side of a 256M memory array. Core array 110 sections (0-31) may 512 word lines in this example. Memory arrays 500 may also include distributed replacement elements 111 (not shown in FIGS. 5A through 5C; see FIG. 1) distributed throughout the sections of the core array 110. Distributed replacement elements 111 may be used as replacement elements for repairing defects associated with word lines of the sections of the core array 110. Distributed replacement elements 111 may also be used to replace word lines of the sections of the core array 110 for reasons other than repairing defects.
Detecting circuitry, such as sense amplifiers 115, are located in the gaps between sections of the core array 110. In an open digit line architecture, a section on one side of the sense amplifiers 115 is used as the active array for a group of sense amplifiers 115, and a section on the other side of the sense amplifiers 115 is used as a reference array for that group of sense amplifiers 115. For example, when section 2 is fired, section 1 or section 3 (not shown) serves as a reference array for the sense amplifiers 115 between sections 1 and 2 (gap 1) or the sense amplifiers 115 between sections 2 and 3 (gap 2), respectively. Similarly, when section 31 is fired, section 30 or section 32 serves as a reference array for the sense amplifiers 115 between sections 30 and 31 (gap 30) or for the sense amplifiers 115 between sections 31 and 32 (gap 31).
In FIG. 5B, a word line may be fired during a refresh operation. In this example, sections 1 and 17 are refreshed (i.e., fired) during the same refresh operation of an 8 k refresh operation. During refresh, when a word line fires in section 1, memory cells coupled to that word line are refreshed by sense amplifiers 115 in both gap 0 and gap 1. As a result, the sense amplifiers 115 in gap 0 use section 0, and the sense amplifiers 115 of gap 1 use section 2, as a reference array to properly refresh the correct charge on the accessed memory cells of section 1. When a word line fires in section 17, memory cells coupled to that word line are refreshed by sense amplifiers 115 in both gap 16 and gap 17. As a result, the sense amplifiers 115 in gap 16 use section 16, and the sense amplifiers 115 in gap 17 use section 18, as a reference array to properly refresh the correct charge on the accessed memory cells of section 17.
In FIG. 5C, a word line may be fired during a refresh operation. Refresh operations conventionally refresh sequentially as a refresh counter increments to generate the refresh address. In this example, sections 2 and 18 are refreshed during the same refresh operation of an 8 k refresh operation. During refresh, when a word line fires in section 2, memory cells coupled to that word line are refreshed by sense amplifiers 115 in both gap 1 and gap 2. As a result, the sense amplifiers 115 in gap 1 use section 1, and the sense amplifiers 115 in gap 2 use section 3, as a reference array to properly refresh the correct charge on the accessed memory cells of section 2. When a word line fires in section 18, memory cells coupled to that word line are refreshed by sense amplifiers 115 in both gap 17 and gap 18. As a result, the sense amplifiers 115 in gap 17 use section 17, and the sense amplifiers 115 in gap 18 use section 19 as a reference array to properly refresh the correct charge on the memory cells of section 18.
A problem may arise when word lines fire during the same refresh operation in adjacent sections of the memory array 500. Detecting circuitry shares the digit lines across the sections. Sharing digit lines across sections allows detecting circuitry to act as a comparator, using an adjacent section as a reference array in order to determine the charge (e.g., 1 or 0) of the memory cells in the array that is being accessed. Under normal circumstances, for example, a sense amplifier turns on to detect either a 1 or a 0 on the memory cell of the accessed array in relation to an adjacent reference array that does not turn on. However, if two adjacent sections are fired in the same refresh operation, the reference function for the sense amplifiers between those two sections may be influenced, which may cause a failure (e.g., from the resulting data corruption) in the refresh operation. In other words, adjacent sections may both send data (rather than reference signals from one side) to sense amplifiers. When a section is fired, adjacent sections which normally are used as a reference may be marginalized because of the common sharing of sense amplifiers.
In the example shown in FIG. 5B, section 1 and section 17 are refreshed during the same refresh operation. If however, a defective element exists in a word line in section 17, then that word line may be replaced (or replaced for other reasons) by re-mapping the address of the word line in section 17 to an address for a distributed replacement element. Suppose for this example, that the distributed replacement element used to replace the defect in section 17 is distributed in section 2. During a conventional refresh operation, when sections 1 and 17 are refreshed, section 1 and the distributed replacement element in section 2 would fire because the address for the word line in section 17 had been replaced by distributed replacement elements in section 2. Because section 1 and section 2 share sense amplifiers in gap 1, data contention on the sense amplifiers may exist. This may cause a failure, and there may be a significantly diminished ability to sense a charge because the reference function needed by the sense amplifiers may not operate properly.
Another problem may arise for the situation when other nearby sections (e.g., one section away) are refreshed during the same refresh operation. For example, if section 3 had been used as the replacement solution (e.g., repair solution) for section 17. In this situation, the data contention issue may not be a problem because section 1 and section 3 do not share a sense amplifier. However, because the sections are nevertheless close in proximity, there may be coupling which may increase noise when the sense amplifiers are fired. With data toggling on signals near each other, weaker sensing margins by the sense amplifiers may be experienced from the induced noise into the sense amplifiers.
In this example, the reference array for section 3 is section 2 or section 4, as the case may be. The reference array for section 1 is section 2 or section 0, as the case may be. In other words, because section 2 acts as a reference array during the same refresh access of both section 1 and section 3, coupling and noise may be increased, which may reduce some of the sensing margins of the sense amplifiers. Accordingly, firing of adjacent sections of the memory array 500 during the same refresh operation may cause failure due to data contention from sharing sense amplifiers with the reference array. Firing of sections of the memory array 500 during the same refresh operation that are nearby (e.g., one section apart) may cause a failure due to increased noise due to coupling between nearby signals.
One way that these problems have conventionally been avoided is to manage the replacement solution rather than the refresh. During replacement, the replacement solution may conventionally be linked across the 8 k word line boundary. In other words, a distributed replacement element in the lower half of the memory array 500 could be used for replacement of, for example, section 1. Conversely, a distributed replacement element in the upper half of the memory array 500 could be used for replacement of, for example, section 17. The locations of the distributed replacement elements to be used are also spaced in relation to each other across the 8 k boundary. In other words, if the distributed replacement element in the lower half (the replacement solution for section 1 in this example) and the distributed replacement element in the upper half (the replacement solution for section 17 in this example) are assured a spacing of 16 sections apart, then there will not be a firing of adjacent or other nearby sections.
For example, if the first word line in section 1 is defective, then that word line is re-mapped to a distributed replacement element in the lower half of the memory array 500. In order to be certain to avoid data contention and/or significant noise under conventional replacement solutions and refresh operations, the first word line in section 17 would also need to be re-mapped (i.e., linked) to a corresponding distributed replacement element in an adjacent repair plane which is linked across the 8 k boundary. This is true regardless of whether or not the first word line in section 17 was defective or otherwise needed replacement. In other words, the replacement of section 17 is tied to (i.e., dependent on) the replacement of section 1, and vice versa. When it comes time to refresh the first word lines in sections 1 and 17, they both have been re-mapped to distributed replacement elements that are linked across the 8 k boundary and appropriately spaced to avoid data contention and/or significant noise, but a distributed replacement element has also potentially been wasted.
Additionally, as more defects in the memory array 500 are repaired (or as other replacements are made), there may be distributed replacement elements available for replacement, but these available distributed replacement elements are not properly spaced for the defective word lines that are to be replaced. Therefore, even though the replacement solution can be effective at avoiding data contention and/or significant noise from refreshing neighboring sections, such problems cannot be assured to be avoided for each distributed replacement element.
The inventors have appreciated that there is a need for methods, memories, and systems regarding refresh of rows within replacement elements of the memory array to avoid or reduce data corruption caused by refreshing row addresses which have been re-mapped to distributed replacement elements near a row (e.g., when distributed replacement elements share a sense amplifier) that is also being refreshed in the same refresh operation. Rather than solving the problem through the replacement solution, the inventors have appreciated that solving the problem during refresh may also increase flexibility to the replacement solution and improve yield.